﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
// 两个Stack实现队列

class MyQueue
{
public:
	//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化

private:
	Stack pushst;
	Stack popst;
};
//int main()
//{
//	Stack st1;
//	st1.Push(1);
//	st1.Push(2);
//	Stack st2(st1);
//	Stack st3 = st1;
//	MyQueue mq1;
//	MyQueue mq2(mq1);
//	return 0;
//}
//Stack func2()
//{
//	Stack st;
//	return st;
//}
//Stack& func3()
//{
//	static Stack st;
//	return st;
//}
//
//int main()
//{
//	Stack st = func2();
//
//	return 0;
//}
//class A
//{
//public:
//	void func()
//	{
//		cout << "A::func" << endl;
//	}
//};
//typedef void(A::* PF)();
//int main()
//{
//	//void (A:: * pf)() = nullptr;
//	PF pf = nullptr;
//	pf = &A::func;
//	A aa;
//	(aa.*pf)();
//}
#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}
	Date operator+(int day);

	Date operator-(int day);

	int operator-(const Date& d);

	//void operator=(const Date& d)
	//{
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}
	Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}
	//private:
	int _year;
	int _month;
	int _day;
};
// 重载为全局的⾯临对象访问私有成员变量的问题

// 有⼏种⽅法可以解决：

// 1、成员放公有

// 2、提供getxxx函数

// 3、友元函数

// 4、重载为成员函数

bool operator==(const Date& d1, const Date& d2)
{
	return d1._year == d2._year
		&& d1._month == d2._month
		&& d1._day == d2._day;
}
int mian()
{
	Date d1(2024, 7, 5);
	Date d2(2024, 7, 6);
	d1 = d2;//赋值重载

	//带初始化就是拷贝构造
	Date d3(d2);
	Date d4 = d3;


	d1 = d4 = d3;
	return 0;
}
//int main()
//{
//	Date d1(2024, 7, 5);
//	Date d2(2024, 7, 6);
//	// 运算符重载函数可以显⽰调⽤
//
//		operator==(d1, d2);
//		d1 == d2;// 编译器会转换成operator==(d1, d2);
//
//		//类域和全局域都有运算符重载时，优先去选择类域的
//		d1.operator==(d2);
//		d1 == d2;//编译器会自动转换成d1.operator==(d2);
//	return 0;
//}